var arr1 = ['0a', '0b', '0c', '0d']
var arr2 = ['0', '1', '2', '3']
var arr4 = ['1', '4', '1', '2', '3', '1']

arr1.concat(arr2) //拼接数组或者元素，返回新数组，不改变

// arr1.pop() //删除数组最后一个元素，并返回，改变

// arr1.shift() // 删除数组第一个元素，并返回，改变

// arr1.push("1a","2b") //数组后添加元素，返回新数组长度，改变

// arr1.unshift("1a","2b") /数组前添加元素，返回新数组长度，改变

// arr1.splice(1,2,"0e","0f") // 如果有删除元素，返回删除元素的数组，否则返回空数组，改变

// arr1.join("") // 将数组元素拼接为字符串，不改变

// arr1.indexOf("0d")  //查找指定元素,有则返回元素索引，否者返回-1

// arr1.lastIndexOf('1') // 找出元素最后出现的位置，没有返回-1

// arr1.reverse() // 元素颠倒顺序 ，返回颠倒后的数组，改变

// arr1.slice(1,3)    //复制指定 左闭右开的 索引段 元素为新的数组，如果只有一个参数，从指定索引，复制到最后

arr4.sort((a, b) => a - b) // 元素按排序，原数组改变,返回
// 返回值 > 0	a 在 b 后，如 [b, a]
// 返回值 < 0	a 在 b 前，如 [a, b]
// 返回值 === 0	保持 a 和 b 原来的顺序

// [...new Set(arr4) ]    //数组去重，new set() 得到的是对象， 原数组不改变

// Array.from(new Set(arr4),item=>item)  //数组去重，原数组不改变,第二参数可选
// Array.from([arr],function,context) 将部署了iterator接口的伪数组转为数组 , 函数里面用到了this关键字，还可以传入第三个参数，用来绑定this
Array.from(new Set(arr4))
Array.from(new Set(arr4), item => item + 1)
Array.from(new Set(arr4), item => item + this.age, { age: 1 })
Array.from({ length: 5 }, (v, i) => i) // [0, 1, 2, 3, 4]

// Array.isArray([]) //判断是否数组

// 1   arr.find() 循环方法 返回满足条件的第一个值，没有就返回undefind
var arr1 = ['0a', '0b', '0c', '0d']
var arr2 = ['-1', '1', '2', '7']
var arr4 = ['4', '1', '2', '3', '1']
console.log(arr2.find(a => a > 2)) //7

// findLast 从后向前查找满足条件的元素，返回该元素，，没有返回undefined
;[('a1', 'b', 'a2')].findLast(x => x.startsWith('a')) // 'a2'
;['a1', 'b', 'a2'].findLastIndex(x => x.startsWith('a')) // 2

// 2   arr.findIndex() 循环方法 返回满足条件的第一个值的索引,没有就返回-1
console.log(arr1.findIndex(a => a === '0c'))

//3   arr.flat(n)   平坦  把数组里嵌套的元素提取出来 n值展开的嵌套乘数，默认1
var arr6 = [1, [2, 3, [4, 5, 6, [7, 8, 9]]]]
console.log(arr6.flat(1)) //[1,2,3,[4,5,6,[7,8,9]]]
console.log(arr6.flat(Infinity)) // 全部展开

//4   arr.includes() 循环方法  包含 判断一个数组是否包含指定的元素,有返回true,否则false
var arr1 = ['0a', '0b', '0c', '0d', ['0g']]
console.log(arr1.includes('0a')) //true
console.log(arr1.includes('0g')) //false

// 5   arr.filter()  过滤  返回满足条件的所有元素为一个新数组
var arr2 = ['-1', '1', '2', '7']
console.log(arr2.filter(a => a > 1))

// 6    arr.map()  数组中每个元素执行一个方法后返回一个新数组,原数组不变
var arr1 = ['0a', '0b', '0c', '0d']
var arr2 = ['0', '1', '2', '7']
var arr4 = ['4', '1', '2', '3', '1']
console.log(arr2.map(a => parseInt(a) + 2))

//7    arr.forEach() 数组中每个元素都执行一个方法，原数组改变
var arr2 = ['-1', '1', '2', '7']
console.log(
	arr2,
	arr2.forEach(a => (num += parseInt(a)))
)

// 8    arr.every()  判断数组中每个元素是否都瞒住条件,都满足，返回true，否者false,空数组返回true,原数组不变
var arr1 = ['0a', '0b', '0c', '0d']
var arr2 = ['0', '1', '2', '7']
var arr4 = ['4', '1', '2', '3', '1']
console.log(
	arr2,
	arr2.every(a => a < 4)
)

//9     arr.some()    判断元素,只要有一个满足条件，返回true，否者false
console.log(arr2.some((value, index) => value > 6))

// new Array() 或者 Array 两个完全一致， 传入一个参数和多个参数不同结果
new Array(2) // [empty x 2]
new Array(1, 2) // [1,2]

// Array.of()：将一组值转为数组，返回数组
Array.of(2) // [2]
Array.of(1, 2) // [1,2]

// 11  fill()：根据指定值填充整个数组，返回原数组
new Array(3).fill(1) // [1,1,1]

// 12 keys()：返回以[索引值]为遍历器的对象
var a = [1, 2, 3].keys()
a.next() // {value:0,done:false}
a.next() // {value:1,done:false}
a.next() // {value:2,done:false}
a.next() // {value:undefined,done:true}

// 13  values()：返回以[属性值]为遍历器的对象
var a = [1, 2, 3].values()
a.next() // {value:1,done:false}
a.next() // {value:2,done:false}
a.next() // {value:3,done:false}
a.next() // {value:undefined,done:true}

// 14 entries()：返回以[索引值和属性值]为遍历器的对象
var a = [10, 20, 30].entries()
a.next() // {value:[0,10],done:false}
a.next() // {value:[1,20],done:false}
a.next() // {value:[2,30],done:false}
a.next() // {value:undefined,done:true}

// 16 flatMap 在 ES10 中，官方还增加了 Array.prototype.flatMap 方法，其实就是 flat 和 map ，filter 一起组合操作：
// 通过返回一个空数组从结果数组中删除该项 filter
// 通过返回一个带有一个新值的数组 [newValue] 来修改映射的项 map
// 通过返回一个包含多个值的数组来添加新项: [newValue1, newValue2, ...] flat
;[1, 3, 5].flatMap(x => [x * x]) // [1,9,25]
;[1, 3, 5].flatMap(x => (x <= 3 ? [] : [x * x])) // [25]
;[[2, 4], [6]].flatMap(x => x) // [2,4,6] 扁平化一层

// 15  copyWithin()：把指定位置的成员复制到其他位置，返回并改变原数组  ，3 个入参 不管他

// TODO：16 at 用于通过给定索引来获取数组元素 ，可正 负
a.at(1) // 20
a.at(-1) // 30
